package czolgisci.tiles;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import utils.geom.Direction;

/**
 * Klasa abstrakcyjna definiująca kafelek. Wszystkie klasy kafelków (np. Czołg,
 * Ściana) muszą po niej dziedziczyć.
 * 
 * @author kasztan
 * @version 1.0
 */
public abstract class ATile
{
	protected BufferedImage image;
	protected BufferedImage srcImage;
	protected Point position;
	protected Direction direction;
	protected Dimension size;
	protected String name;

	/**
	 * konstruktor
	 * @param imagePath ścieżka do pliku graficznego reprezentującego kafelek
	 * @param pos pozycja początkowa
	 * @throws IOException
	 */
	public ATile(String imagePath, Point pos) throws IOException
	{
		image = (BufferedImage) ImageIO.read(new File(imagePath));
		srcImage = new BufferedImage(image.getColorModel(), image
				.copyData(null), image.isAlphaPremultiplied(), null);

		size = new Dimension(image.getWidth(), image.getHeight());
		position = pos;
		direction = Direction.NORTH;
	}

	/**
	 * zwalnia pamięć
	 */
	public void destroy()
	{
		image.flush();
	}

	/**
	 * @return dokładny obszar zajmowany przez obiekt klasy dziedziczącej (co do
	 *         pixela)
	 */
	public Rectangle getArea()
	{
		return new Rectangle(position, size);
	}

	/**
	 * @return kierunek w którym zwrócony jest obiekt klasy dziedziczącej po ATile
	 */
	public Direction getDirection()
	{
		return direction;
	}

	/**
	 * @return obrazek kafelka
	 */
	public BufferedImage getImage()
	{
		return image;
	}

	/**
	 * @return unikalne imię nadane obiektowi
	 */
	public String getName()
	{
		return name;
	}

	/**
	 * @return współrzędne pozycji
	 */
	public Point getPosition()
	{
		return (Point) position.clone();
	}

	/**
	 * @return wymiar obszaru zajmowanego przez kafelek
	 */
	public Dimension getSize()
	{
		return size;
	}

	/**
	 * Ustawia obszar na którym będzie znajdował się dany kafelek
	 * @param rect
	 *            obszar który kafelek może zajmować (rect ma w sobie zarówno
	 *            szerokość, wysokość jak i współrzędne położenia x, y
	 */
	public void setArea(Rectangle rect)
	{
		size = rect.getSize();
		position = rect.getLocation();
	}

	/**
	 * @param direction
	 *            kierunek w którym będzie zwracał się kafelek
	 */
	public void setDirection(Direction dir)
	{
		if (dir != direction)
		{
			direction = dir;
			Graphics2D imageG2D = image.createGraphics();
			imageG2D.setBackground(new Color(0, 0, 0, 0));
			imageG2D.clearRect(0, 0, size.width, size.height);
			imageG2D.rotate(Math.toRadians(dir.getRotation()),
					size.getWidth() / 2, size.getHeight() / 2);
			imageG2D.drawImage(srcImage, null, 0, 0);
			imageG2D.dispose();
		}
	}

	/**
	 * @param image
	 *            obrazek reprezentujący kafelek na ekranie
	 */
	public void setImage(BufferedImage image)
	{
		this.image = image;
		size.width = image.getWidth();
		size.height = image.getHeight();
	}

	/**
	 * @param name
	 *            unikalne imię kafelka (może to być np. imię gracza sterującego
	 *            czołgiem)
	 */
	public void setName(String nameId)
	{
		this.name = nameId;
	}

	/**
	 * @param pt
	 *            współrzędne położenia
	 */
	public void setPosition(Point pt)
	{
		position = (Point) pt.clone();
	}

	public void setX(int x)
	{
		position.x = x;
	}

	public void setY(int y)
	{
		position.y = y;
	}

	/**
	 * @param rect
	 *            wymiary zajmowanego obszaru
	 */
	public void setSize(Dimension size)
	{
		this.size = size;
	}
}
